package com.malie.myspringboot.thread.createThread;

import org.junit.Test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池
 * 优点：通过复用已创建的线程，降低资源损耗、线程可以直接处理队列中的任务加快响应速度、同时便于统一监控和管理。
 */
public class DefaultThreadFactory {

    /**
     * **newCachedThreadPool()：**线程池里有很多线程需要同时执行，60s内复用，适用执行很多短期异步的小程序或者负载较轻的服务
     */
    @Test
    public void createCachedThreadPool() {

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                //sleep	让当前正在执行的线程休眠（暂停执行）
                Thread.sleep(1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }

    /**
     * newSingleThreadExecutor()：**只有一个线程的线程池，任务是顺序执行，适用于一个一个任务执行的场景
     */
    @Test
    public void createSingleThread() {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 3; i++) {
            final int index = i;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleThreadPool.execute(() -> System.out.println(index));
        }
    }

    /**
     * **newFixedThreadPool()：**拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务
     */
    @Test
    public void createFixedThread() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                final int index = i;

                fixedThreadPool.execute(() -> System.out.println(index));

            }
        }

    }

}
